import { getNewCartGoods, mergeCart, findCart, insertCart, 
    deleteCartGoods, updateCartGoods, checkAllCart} from '@/api/cart'

export default {
    namespaced: true,
    state() {
        return {
            list: []
        }
    },
    getters: {
        // 有效商品列表
        validList(state) {
            // 有效商品：库存大于0  stock  商品有效标识为  true  isEffective
            return state.list.filter(goods => goods.stock > 0 && goods.isEffective)
        },
        // 有效商品总数
        validTotal(_, getters) {
            return getters.validList.reduce((p, c) => p + c.count, 0)
        },
        // 有效商品总金额
        validAmount(_, getters) {
            return getters.validList.reduce((p, c) => p + parseInt(c.count * c.nowPrice * 100) / 100, 0)
        },

        // 无效商品列表
        inValidList(state,){
            return state.list.filter(goods => goods.stock <= 0 || !goods.isEffective)
        },
        // 已选中商品列表
        selectedList(_,getters){
            return getters.validList.filter(item=>item.selected)
        },
        // 已选中商品总数
        selectTotal(_,getters){
            return getters.selectedList.reduce((p, c) => p + c.count, 0)
        },
        // 已选中商品总金额
        selectAmount(_, getters){
            return getters.selectedList.reduce((p, c) => p + parseInt(c.count * c.nowPrice * 100) / 100, 0)
        },
        // 是否全选
        isCheckAll(_,getters){
            return getters.validList.length!==0 && getters.validList.length === getters.selectedList.length
        }

    },
    mutations: {
        //  加入购物车
        INSERT_CART(state, payload) {
            // 约定加入购物车字段必须和后端保持一致 payload对象 的字段
            // 它们是：id skuId name attrsText picture price nowPrice selected stock count isEffective
            // 插入数据规则：
            // 1. 先找下是否有相同商品
            // 2. 如果有相同的商品，查询它的数量，累加到payload上，再保存最新位置，原来商品需要删除
            // 3. 如果没有相同商品，保存在最新位置即可
            const goodsIndex = state.list.findIndex(v => v.skuId === payload.skuId)
            console.log(goodsIndex);
            if (goodsIndex !== -1) {
                const count = state.list[goodsIndex].count
                payload.count += count
                state.list.splice(goodsIndex, 1)
                state.list.unshift(payload)
            }
            state.list.unshift(payload)
        },

        // 更新本地购物车
        UPDATE_CART(state, goods) {
            // goods 商品信息：nowPrice stock isEffective
            // goods 商品对象的字段不固定，对象中有哪些字段就改哪些字段，字段的值合理才改
            // goods 商品对象 必需有SKUID
            const updateGoods = state.list.find(item => item.skuId === goods.skuId)
            // 对goods字段的保存
            for (const key in goods) {
                if (goods[key] !== undefined && goods[key] !== null && goods[key] !== '') {
                    updateGoods[key] = goods[key]
                }
            }
        },

        // 删除购物车商品
        DELETE_CART(state, skuOd){
            const index = state.list.findIndex(item=>item.skuId===skuOd)
            state.list.splice(index, 1)
        },

        // 设置购物车 (可用于删除)
        SET_CART(state, payload){
            state.list = payload
        }
    },
    actions: {

        // 合并购物车
       async mergeCartGoods(context, ){
            
            const cartList = context.state.list.map(goods=>{
                return {
                    skuId:goods.skuId,
                    selected:goods.selected,
                    count:goods.count
                }
            })
            await mergeCart(cartList)
            // 同步成功 清空本地购物车
            context.commit('SET_CART', [])
        },

        // 全选
        checkAll(context, selected){
            return new Promise((resolve, reject) => {
                // 判断是否登录
                if (context.rootState.user.profile.token) {
                    // 已登录
                    const ids = context.getters.validList.map(goods=>goods.skuId)
                    checkAllCart({selected, ids}).then(()=>{
                        return findCart()
                    }).then(data=>{
                        context.commit('SET_CART', data.result)
                        resolve()
                    })
                } else {
                    // 未登录
                    context.getters.validList.forEach(goods=>{
                        context.commit('UPDATE_CART', {skuId:goods.skuId, selected})
                    })
                    resolve()
                }
            })
        },

        // 添加购物车
        insertCart(context, payload) {
            return new Promise((resolve, reject) => {
                // 判断是否登录
                if (context.rootState.user.profile.token) {
                    // 已登录
                    insertCart({skuId:payload.skuId, count:payload.count}).then(()=>{
                        return findCart()
                    }).then(data=>{
                        context.commit('SET_CART', data.result)
                        resolve()
                    })
                } else {
                    // 未登录
                    context.commit('INSERT_CART', payload)
                    resolve()
                }
            })
        },

        // 修改购物车 （选中， 数量）
        updateCart(context, payload){
            return new Promise((resolve, reject) => {
                // 判断是否登录
                if (context.rootState.user.profile.token) {
                    // 已登录
                    updateCartGoods(payload).then(()=>{
                        return findCart()
                    }).then(data=>{
                        context.commit('SET_CART', data.result)
                        resolve()
                    })
                } else {
                    // 未登录
                    context.commit('UPDATE_CART', payload)
                    resolve()
                }
            })
        },

        // 修改购物车商品规格
        updateCartSku(context, {oldSkuId, newSku}){
            return new Promise((resolve, reject) => {
                // 判断是否登录
                if (context.rootState.user.profile.token) {
                    // 已登录
                    // 1. 找出旧的商品信息
                    // 2. 删除旧商品数据
                    // 3. 原先商品的数量+新skuId
                    // 4. 添加新的商品
                    const oldGoods = context.state.list.find(goods=>goods.skuId === oldSkuId)
                    deleteCartGoods([oldGoods.skuId]).then(()=>{
                        return insertCart({skuId:newSku.skuId, count:oldGoods.count})
                    }).then(()=>{
                        return findCart()
                    }).then(data=>{
                        context.commit('SET_CART', data.result)
                        resolve()
                    })
                } else {
                    // 1. 找出旧的商品信息
                    // 2. 删除旧商品数据
                    // 3. 根据新的sku信息和旧的商品信息，合并成一条新的购物车商品数据
                    // 4. 添加新的商品
                    const oldGoods = context.state.list.find(item => item.skuId === oldSkuId)
                    context.commit('DELETE_CART', oldSkuId)
                    const { skuId, price: nowPrice, specsText: attrsText, inventory: stock } = newSku
                    const newGoods = { ...oldGoods, skuId, nowPrice, attrsText, stock }
                    context.commit('INSERT_CART', newGoods)
                    resolve()
                }
            })
        },

        // 获取 更新商品列表
        findGoods(context) {
            return new Promise((resolve, reject) => {
                // 判断是否登录
                if (context.rootState.user.profile.token) {
                    // 已登录
                    findCart().then(res=>{
                        context.commit('SET_CART', res.result)
                        resolve()
                    })
                } else {
                    // 未登录
                    // 同时发送请求（有几个商品发几个请求）等所有请求成功，一并去修改本地数据。
                    // Promise.all(promise数组).then((dataList)=>{})  同时发请求，所有请求成功，得到所有成功结果
                    // Promise.resolve() Promise.reject() new Promise()
                    // Promise.race(promise数组).then((data)=>{}) 同时发请求，最快的请求成功，得到成功结果

                    const peomiseArr = context.state.list.map(goods=> getNewCartGoods(goods.skuId))
                    // dataList成功结果的集合，数据顺序和promiseArr顺序一致，它又是根据state.list而来
                    Promise.all(peomiseArr).then(res_list=>{
                        res_list.forEach((res,i)=>{
                            context.commit('UPDATE_CART', 
                            {skuId:context.state.list[i].skuId,...res.result}
                            )
                        })
                        resolve()
                    })
                }
            })
        },

        // 删除购物车
        deleteCart(context, payload) {
            return new Promise((resolve, reject) => {
                // 判断是否登录
                if (context.rootState.user.profile.token) {
                    // 已登录
                    deleteCartGoods([payload]).then(()=>{
                        return findCart()
                    }).then(data=>{
                        context.commit('SET_CART', data.result)
                        resolve()
                    })
                } else {
                    // 未登录
                    context.commit('DELETE_CART', payload)
                    resolve()
                }
            })
        },

        // 批量删除购物车
        batchDeleteCart(context, clear){
            return new Promise((resolve, reject) => {
                // 判断是否登录
                if (context.rootState.user.profile.token) {
                    // 已登录
                    const ids =  context.getters[clear===true? 'inValidList' : 'selectedList' ].map(goods=>goods.skuId)
                    deleteCartGoods(ids).then(()=>{
                        return findCart()
                    }).then(data=>{
                        context.commit('SET_CART', data.result)
                        resolve()
                    })
                } else {
                    // 未登录
                    // 找出选中的商品列表，遍历调用删除的mutations
                    // isClear 未 true  删除失效商品列表，否则事选中的商品列表
                    context.getters[clear===true? 'inValidList' : 'selectedList' ].forEach(item=>{
                        context.commit('DELETE_CART', item.skuId)
                    })
                    resolve()
                }
            })
        }
    }
}
